/*
 * Copyright 2012 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.smartthinking.dive;

import static com.smartthinking.dive.CommonUtilities.SERVER_URL;
import static com.smartthinking.dive.CommonUtilities.TAG;
import static com.smartthinking.dive.CommonUtilities.displayMessage;

import com.google.android.gcm.GCMRegistrar;

import android.content.Context;
import android.content.pm.PackageManager.NameNotFoundException;
import android.content.res.Resources.NotFoundException;
import android.util.Log;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Random;

/**
 * Helper class used to communicate with the demo server.
 */
public final class ServerUtilities {

    private static final int MAX_ATTEMPTS = 5;
    private static final int BACKOFF_MILLI_SECONDS = 2000;
    private static final Random random = new Random();
    public static Context Context_;
    public static String RegId;
    
    /**
     * Register this account/device pair within the server.
     *
     * @return whether the registration succeeded or not.
     */
    static boolean register(final Context context, final String regId) throws IOException {
    	RegId = regId;
    	Context_ = context;
    	
        Log.i(TAG, "registering device (regId = " + regId + ")");
        String serverUrl = SERVER_URL + "postmethod.php";
        Map<String, String> params = new HashMap<String, String>();
        params.put("regId", regId);
        long backoff = BACKOFF_MILLI_SECONDS + random.nextInt(1000);
        // Once GCM returns a registration id, we need to register it in the
        // demo server. As the server might be down, we will retry it a couple
        // times.
        for (int i = 1; i <= MAX_ATTEMPTS; i++) {
            Log.d(TAG, "Attempt #" + i + " to register");
            displayMessage(context, context.getString(
			        R.string.server_registering, i, MAX_ATTEMPTS));
//                post(serverUrl, params);
			insertRegId();
			GCMRegistrar.setRegisteredOnServer(context, true);
			String message = context.getString(R.string.server_registered);
			CommonUtilities.displayMessage(context, message);
			return true;
        }
        String message = context.getString(R.string.server_register_error,
                MAX_ATTEMPTS);
        CommonUtilities.displayMessage(context, message);
        return false;
    }

    private static void insertRegId() {
    	try{
    	ArrayList<Dictionary<String, String> > listainsertregid = null;

    	if(Utilities.isNetwork()){

//    		String url="update clientes set cliente_token='"+RegId+
//    				"' where cliente_udid='"+Utilities.getUDID(Context_)+"'";


    		String versionNames = null;
    		try {
    			versionNames = Context_.getPackageManager().getPackageInfo(Context_.getPackageName(), 0).versionName;
    		} catch (NameNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}

    		String insertquery = "INSERT INTO usuarios(usu_idr,usu_udid, usu_token, usu_model, usu_osversion, usu_appversion, usu_fecha)" +
    				"select (select coalesce(max(usu_idr)%2B1,1) from usuarios),'"+Utilities.getUDID(Context_)+"', " +
    				"'"+RegId+"', 'Android', '"+android.os.Build.VERSION.SDK_INT+"', '"+versionNames+"', " +
    				"now()";
    		Log.i("INSERT QUERY", ""+insertquery);
    		listainsertregid = Utilities.qry3(Context_, insertquery.replace(" ", "%20"));

    		if(listainsertregid.size() > 0){

    			if(listainsertregid.get(0).get("RETURN").equals("1")){

    				Log.i("Mensaje","Insert corretco");
    			}

    		}else{

    			Log.i("Mensaje","Error de consulta");

    		}

    	}
    	} catch (NotFoundException e) {
			// TODO Auto-generated catch block
		}
    }

	/**
     * Unregister this account/device pair within the server.
     */
    static void unregister(final Context context, final String regId) {
        Log.i(TAG, "unregistering device (regId = " + regId + ")");
        String serverUrl = SERVER_URL + "/unregister";
        Map<String, String> params = new HashMap<String, String>();
        params.put("regId", regId);
        try {
            post(serverUrl, params);
            GCMRegistrar.setRegisteredOnServer(context, false);
            String message = context.getString(R.string.server_unregistered);
            CommonUtilities.displayMessage(context, message);
        } catch (IOException e) {
            // At this point the device is unregistered from GCM, but still
            // registered in the server.
            // We could try to unregister again, but it is not necessary:
            // if the server tries to send a message to the device, it will get
            // a "NotRegistered" error message and should unregister the device.
            String message = context.getString(R.string.server_unregister_error,
                    e.getMessage());
            CommonUtilities.displayMessage(context, message);
        }
    }

    /**
     * Issue a POST request to the server.
     *
     * @param endpoint POST address.
     * @param params request parameters.
     *
     * @throws IOException propagated from POST.
     */
    private static void post(String endpoint, Map<String, String> params)
            throws IOException {
        URL url;
        try {
            url = new URL(endpoint);
        } catch (MalformedURLException e) {
            throw new IllegalArgumentException("invalid url: " + endpoint);
        }
        StringBuilder bodyBuilder = new StringBuilder();
        Iterator<Entry<String, String>> iterator = params.entrySet().iterator();
        // constructs the POST body using the parameters
        while (iterator.hasNext()) {
            Entry<String, String> param = iterator.next();
            bodyBuilder.append(param.getKey()).append('=')
                    .append(param.getValue());
            if (iterator.hasNext()) {
                bodyBuilder.append('&');
            }
        }
        String body = bodyBuilder.toString();
        Log.v(TAG, "Posting '" + body + "' to " + url);
        byte[] bytes = body.getBytes();
        HttpURLConnection conn = null;
        try {
            conn = (HttpURLConnection) url.openConnection();
            conn.setDoOutput(true);
            conn.setUseCaches(false);
            conn.setFixedLengthStreamingMode(bytes.length);
            conn.setRequestMethod("POST");
            conn.setRequestProperty("Content-Type",
                    "application/x-www-form-urlencoded;charset=UTF-8");
            // post the request
            OutputStream out = conn.getOutputStream();
            out.write(bytes);
            out.close();
            // handle the response
            int status = conn.getResponseCode();
            if (status != 200) {
            	Log.i("response code", ""+status);
            	throw new IOException("Post failed with error code " + status);
            }else{
            	Log.i("response code", ""+status);
            	InputStream input = conn.getInputStream();
            	BufferedReader reader = new BufferedReader(new InputStreamReader(input, "utf-8"));
            	StringBuilder sb = new StringBuilder();
            	int Bytes = -1;
            	char respuesta[] = new char[1024];
            	String line = null;
            	if((Bytes = reader.read(respuesta)) != -1){
            		line = String.copyValueOf(respuesta, 0, Bytes);
            		Log.i("Respuesta del servidor", ""+line);
            		sb.append(line);
            	}
            	Log.i("RESPUESTA BUILDER", ""+sb.toString());
            	
//            	StringBuilder builder = new StringBuilder();
//            	String linea;
//            	while((linea = reader.readLine()) != null){
//            		builder.append(linea);
//            	}
//            	Log.i("RESPUESTA", ""+builder.toString());
            	input.close();
            }
        } finally {
            if (conn != null) {
                conn.disconnect();
            }
        }
      }
}
